// fn find_biggest(list: &Vec<i32>) -> i32 {
fn find_biggest(list: &[i32]) -> i32 {
    let mut biggest: i32 = list[0];

    for l in list {
        if *l > biggest {
            biggest = *l;
        }
    }
    biggest
}

struct Point<T> {
    x: T,
    y: T,
}

// 针对泛型Tde
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }

    // 调用 Point::<&str>::q()
    fn q() -> i32 {
        12
    }
}

// 只有在i32这个类型上才存在x_1这个方法
impl Point<i32> {
    fn x_1(&self) -> &i32 {
        &self.x
    }
}

struct PointP {
    a: String,
    b: i32,
}

impl PointP {
    fn q() -> i32 {
        2
    }
}

// Trait
// - 告诉编辑器，某种类型具有哪些并且可以与其他类型共享的功能
// - 抽象的定义共享行为
// - Trait bounds(约束)：泛型类型参数指定为实现了特定行为的类型

// 定义方式
// - 把方法签名放在一起，来定义实现某种目的所必须的一组行为
// - 只有方法签名，没有具体实现
// - 可以有多个方法：每个方法占一行，以;结尾
// - 实现该trait的类型必须提供具体的方法实现

// 在类型上实现trait
// - impl trait关键字 for 类型{}

// 默认实现
// 为trait中的某些或者所有方法提供默认行为是非常有用的
// 它可以使用我们无需为每一个类型的使用都提供自定义的行为
// 我们可以针对某些特定的类型实现trait里面的方法
// 当我们为某个特定类型实现trait是，我们可以选择保留果实重载某个方法的默认实现
// 无法从方法的重写视线中调用默认的实现

use my_pratice_10::Nname;
use my_pratice_10::Person;
fn main() {
    let list = vec![12, 34, 21, 35, 23, 56, 45];

    println!("biggest:{}", find_biggest(&list));

    //
    let p = Point { x: 32, y: 32 };
    let p1 = Point {
        x: "文字文字x",
        y: "文字文字y",
    };
    println!("x_1: {}", p.x_1());
    println!("x: {}", p1.x());
    println!("x: {}", PointP::q());
    let p = Person {
        name: String::from("dksdds"),
        kk: String::from("hdfiuashd"),
    }.get_name();
    println!("{}",p);
}
